home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / demos / video / bigvideoin.c < prev    next >
C/C++ Source or Header  |  1994-08-01  |  9KB  |  358 lines
  1. /*
  2.  * Copyright (C) 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. /*
  18.  * File:          bigvideoin
  19.  *
  20.  * Usage:         bigvideoin [-b] [-p] [-h]
  21.  *
  22.  * Description:   bigvideoin demonstrates zoomed videoin inside a large window.
  23.  *          This application only runs on video hardware 
  24.  *                that has a video output port. It will not run 
  25.  *            on a VINO video board. 
  26.  *
  27.  *          sort of a hybrid of simple2vs and videoin.
  28.  *          last modified  2/28/94 atang
  29.  *
  30.  */
  31. #include <stdlib.h>
  32. #include <stdio.h>
  33. #include <X11/X.h>
  34. #include <X11/Xlib.h>
  35. #include <Xm/MwmUtil.h>
  36. #include <X11/Xutil.h>
  37. #include <vl/vl.h>
  38.  
  39. /* defines */
  40. #define ESC_KEY '\006'
  41. #define USAGE \
  42. "%s: [-b] [-h]\n\
  43. \t-b\tno window borders\n\
  44. \t-p x y\twindow position (must be last option if specified)\n\
  45. \t-h\tthis help message\n"
  46.  
  47.  
  48. /* function prototypes */
  49. void    VideoTracking(Window, int,int);
  50. void    processXEvent(uint, void *);
  51. void    processVLEvent(VLServer, VLEvent *, void *);
  52. void    docleanup(void);
  53. void    noborders(Display *, Window);
  54.  
  55. /* globals */
  56. VLServer    svr;
  57. VLPath        path;
  58. Display        *dpy;
  59. Window        vwin;
  60. VLNode        src, drn;
  61. int        win_border = True;
  62. int        init_position = False;
  63. char        *_progname;
  64. int        init_x = 0;
  65. int        init_y = 0;
  66. int        input_timing;
  67.  
  68. Atom WM_DELETE_WINDOW;
  69. Atom WM_PROTOCOLS;
  70.  
  71.  
  72. /* 
  73.  * Set the window property telling motif-compatible window
  74.  * managers (e.g., 4Dwm) to not put any border on this window.
  75.  */
  76. void
  77. noborders(Display *display, Window win)
  78. {
  79.     MwmHints mwmhints;
  80.     Atom MOTIF_WM_HINTS; 
  81.     
  82.     mwmhints.flags = MWM_HINTS_DECORATIONS;
  83.     mwmhints.decorations = 0 /* MWM_DECOR_BORDER */;
  84.     MOTIF_WM_HINTS = XInternAtom(display, "_MOTIF_WM_HINTS", False);
  85.     XChangeProperty(display, win, MOTIF_WM_HINTS, MOTIF_WM_HINTS,
  86.                 sizeof(long)*8, PropModeReplace,
  87.                 (unsigned char*) &mwmhints,
  88.                 sizeof(mwmhints) / sizeof(long));
  89. }
  90.  
  91. main(int argc, char **argv)
  92. {
  93.     VLControlValue val; 
  94.     int x, y, c, win_x,win_y;
  95.     uint w, h, bw, d;
  96.     Window dummyWin;
  97.     XSizeHints size_hints;
  98.     Atom WM_PROT_SET[2];
  99.     Atom _SGI_VIDEO;
  100.  
  101.     _progname = argv[0];
  102.  
  103.     while ((c = getopt(argc, argv, "hbp")) != EOF) 
  104.     {
  105.     switch(c) 
  106.     {
  107.         case 'b':
  108.         win_border = 0;
  109.         break;
  110.         
  111.         case 'h':
  112.         fprintf(stderr, USAGE, _progname);
  113.         exit(0);
  114.         break;
  115.         case 'p':
  116.         init_x = atoi(argv[optind-1]);
  117.         init_y = atoi(argv[optind]);
  118.         if ((init_y < 0) || (init_x < 0))
  119.         {
  120.             fprintf(stderr,
  121.                 "%s: x and y coordinates must be non-negative.\n",
  122.                 _progname);
  123.             opterr = 1;
  124.         }
  125.         init_position = 1;
  126.         break;
  127.             
  128.     }
  129.     }
  130.  
  131.     /* Open an X display */
  132.     if (!(dpy = XOpenDisplay("")))
  133.     exit(1);
  134.     
  135.     /* Connect to the video daemon */
  136.     if (!(svr = vlOpenVideo("")))
  137.     exit(1);
  138.  
  139.     /* Create a source node on a video device */
  140.     src = vlGetNode(svr, VL_SRC, VL_VIDEO, VL_ANY);
  141.     
  142.     /* Create a drain node on the screen */
  143.     drn = vlGetNode(svr, VL_DRN, VL_SCREEN, VL_ANY);
  144.     
  145.     /* Create a path on the first device that supports it */
  146.     if((path = vlCreatePath(svr, VL_ANY, src, drn)) < 0)
  147.         exit(1);
  148.     
  149.      /* Set up the hardware for and define the usage of the path */
  150.     vlSetupPaths(svr, (VLPathList)&path, 1, VL_SHARE, VL_SHARE);
  151.  
  152.     /* get the current input timing */
  153.     vlGetControl(svr, path, src, VL_TIMING, &val);
  154.     input_timing = val.intVal;
  155.  
  156.     /* size considerations */
  157.     vlGetControl(svr, path, drn, VL_SIZE, &val);
  158.     x = val.xyVal.x;
  159.     y = val.xyVal.y;
  160.     if ((input_timing == VL_TIMING_625_SQ_PIX) || 
  161.     (input_timing == VL_TIMING_625_4FSC))
  162.     {/* PAL */
  163.     win_x = 1280;
  164.     win_y = 1020;
  165.     }else
  166.     {/* NTSC */
  167.     win_x = 1280;
  168.     win_y = 972;
  169.     }
  170.  
  171.     /* Get the window's origin */
  172.     vlGetControl(svr, path, drn, VL_ORIGIN, &val);
  173.     x = val.xyVal.x;
  174.     y = val.xyVal.y;
  175.     /* If user requested initial window position */
  176.     if (init_position)    
  177.     {
  178.     x = init_x;
  179.     y = init_y;    
  180.     }
  181.     vwin = XCreateWindow(dpy, RootWindow(dpy, 0), x, y, win_x, win_y, 0,
  182.                 CopyFromParent, CopyFromParent, CopyFromParent,
  183.                 (ulong) 0, NULL);
  184.  
  185.     _SGI_VIDEO = XInternAtom(dpy, "_SGI_VIDEO", False);
  186.     WM_DELETE_WINDOW = XInternAtom(dpy, "WM_DELETE_WINDOW", False);
  187.     WM_PROTOCOLS = XInternAtom(dpy, "WM_PROTOCOLS", False);
  188.     WM_PROT_SET[0] = WM_DELETE_WINDOW;
  189.     WM_PROT_SET[1] = _SGI_VIDEO;
  190.     XSetWMProtocols(dpy,vwin, WM_PROT_SET, 2);
  191.     XStoreName(dpy, vwin, "video input");
  192.  
  193.     /* If the user requested no window borders kill the borders */
  194.     if (!win_border)        
  195.     noborders(dpy, vwin); 
  196.  
  197.     /* Ignore window manager placement set the window to 10, 10 */
  198.     size_hints.flags = USPosition;
  199.     size_hints.x = 10;
  200.     size_hints.y = 10;
  201.     XSetWMNormalHints(dpy, vwin, &size_hints);
  202.  
  203.     XMapWindow(dpy, vwin);
  204.     XSelectInput(dpy, vwin, KeyPressMask|VisibilityChangeMask
  205.                 |ExposureMask|StructureNotifyMask);
  206.     XSync(dpy, 0);
  207.  
  208.     /* Set up zoom factor*/
  209.     val.fractVal.numerator = 2;
  210.     val.fractVal.denominator = 1;
  211.     vlSetControl(svr, path, drn, VL_ZOOM, &val);
  212.     
  213.     /* Set the X window to be the drain */
  214.     val.intVal = vwin;
  215.     vlSetControl(svr, path, drn, VL_WINDOW, &val); 
  216.     
  217.     /* Get X and VL into the same coordinate system */   
  218.     XTranslateCoordinates(dpy, vwin, RootWindow(dpy, DefaultScreen(dpy)),
  219.                           0, 0,&x, &y, &dummyWin);
  220.               
  221.     /* Set the live video to the same location and size as the X window */   
  222.     val.xyVal.x = x;
  223.     val.xyVal.y = y;
  224.     vlSetControl(svr, path, drn, VL_ORIGIN, &val); 
  225.     
  226.     XGetGeometry(dpy, vwin, &dummyWin, &x, &y, &w, &h, &bw, &d);
  227.     val.xyVal.x = w;
  228.     val.xyVal.y = h;
  229.     vlSetControl(svr, path, drn, VL_SIZE, &val);
  230.  
  231.     /* allow for X event processing */
  232.     vlRegisterHandler(svr, ConnectionNumber(dpy), processXEvent,
  233.               (VLPendingFunc)XPending, dpy);
  234.               
  235.     /* Set up event handler routine as callback for all events */
  236.     vlAddCallback(svr, path, VLAllEventsMask, processVLEvent, NULL);
  237.  
  238.     /* Set the VL event mask so we only get control changed events */
  239.     vlSelectEvents(svr, path, VLControlChangedMask);
  240.  
  241.     /* Begin the data transfer */
  242.     vlBeginTransfer(svr, path, 0, NULL);        
  243.  
  244.     vlMainLoop();
  245. }
  246.  
  247.  
  248. /*
  249.  * VideoTracking - if the user changes the size of the window, 
  250.  * update the video to reflect the new size and position.
  251.  */
  252. void
  253. VideoTracking(Window win, int x, int y)
  254. {
  255.     Window dummyWin;
  256.     VLControlValue val;
  257.  
  258.     /* Get X's idea of origin */
  259.     XTranslateCoordinates(dpy, win, RootWindow(dpy, DefaultScreen(dpy)),
  260.                           0, 0,
  261.                           &x, &y,
  262.                           &dummyWin);
  263.  
  264.     /* Try to make vl match X */
  265.     val.xyVal.x = x;
  266.     val.xyVal.y = y;
  267.     vlSetControl(svr, path, drn, VL_ORIGIN, &val);
  268.  
  269. }
  270.  
  271. /* 
  272.  * VLEvent processing for video to screen.
  273.  * We only deal with control changed events.
  274.  */
  275. void
  276. processVLEvent(VLServer vlSvr, VLEvent *ev, void *dummy)
  277. {
  278.     VLControlChangedEvent *cev = (VLControlChangedEvent *) ev;
  279.     VLControlValue val;
  280.  
  281.     switch (ev->reason)
  282.     {   /* Ignore all but a change in the drain's location */
  283.     case VLControlChanged:
  284.         if ((cev->type == VL_ORIGIN)&&(cev->node == drn))
  285.         {
  286.             /* Drain moved, move window accordingly */
  287.         vlGetControl(svr, path, drn, VL_ORIGIN, &val);
  288.         XMoveWindow(dpy, vwin, val.xyVal.x, val.xyVal.y);
  289.         }
  290.     break;
  291.     }
  292. }
  293. /* XEvent processing for video to screen */
  294. void
  295. processXEvent(uint fd, void *source)
  296. {
  297.     int i;
  298.  
  299.     if (source == (caddr_t)dpy) 
  300.     {
  301.     XEvent ev;
  302.     
  303.     XNextEvent(dpy, &ev);
  304.     switch (ev.type) 
  305.     {
  306.         case ClientMessage:
  307.          if (ev.xclient.message_type == WM_PROTOCOLS)
  308.             if (ev.xclient.data.l[0] == WM_DELETE_WINDOW)
  309.             docleanup();
  310.         break;
  311.         
  312.         case Expose:        /* These really don't affect us */
  313.         case GraphicsExpose:
  314.         case VisibilityNotify:
  315.         break;
  316.         
  317.         case ConfigureNotify:       /* Window moved or changed size */
  318.         VideoTracking(ev.xany.window, ev.xconfigure.x,ev.xconfigure.y);
  319.         break;
  320.         
  321.         case KeyPress: 
  322.         {
  323.         XKeyEvent *kev = (XKeyEvent *)&ev;
  324.         KeySym keysym;
  325.         char buf[4];
  326.                 
  327.         XLookupString(kev, buf, 1, &keysym, 0);
  328.         switch (buf[0]) 
  329.         {   /* Quit */
  330.             case 'q':
  331.             case 'Q':
  332.             case ESC_KEY:
  333.             docleanup();
  334.             break;
  335.             
  336.             default:
  337.             break;
  338.         }
  339.         }
  340.     }
  341.     }
  342. }
  343.  
  344. /* Dispose of the vl structures */
  345. void
  346. docleanup()
  347. {   /* End the data transfer */
  348.     vlEndTransfer(svr, path);
  349.      
  350.     /* Destroy the path, free it's memory */
  351.     vlDestroyPath(svr, path);
  352.  
  353.     /* Disonnect from the daemon */
  354.     vlCloseVideo(svr);
  355.  
  356.     exit(0);
  357. }
  358.